home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Compilers⁄Interps / kevoSource / portEvents.c < prev    next >
Text File  |  1993-05-16  |  44KB  |  1,649 lines
  1. /* Kevo -- a prototype-based object-oriented language */
  2. /* (c) Antero Taivalsaari 1991-1993                   */
  3. /* Some parts (c) Antero Taivalsaari 1986-1988           */
  4. /* portEvents.c: The graphical user interface event manager */
  5.  
  6. #include "global.h"
  7. #include "portGlobal.h"
  8.  
  9. /*---------------------------------------------------------------------------*/
  10. /* Graphical user interface (GUI) initialization */
  11.  
  12. /* initGUI(): initialize the graphical user interface */
  13. void initGUI()
  14. {
  15.   WindowPtr newWindow;
  16.   GrafPtr    savePort;
  17.   TEHandle    newText;
  18.   WINFO*    newWinfo;
  19.   Rect        viewRect, destRect;
  20.   WStateData** wDataHdl;
  21.   
  22.     InitGraf(&thePort);
  23.     InitFonts();
  24.     FlushEvents(everyEvent, 0);
  25.     InitWindows();
  26.     InitMenus();
  27.     TEInit();
  28.     InitDialogs(0L);
  29.     InitCursor();
  30.     MaxApplZone();
  31.  
  32.     /* Set the default window growing and dragging limits */
  33.     SetRect(&limitRect, 16, 24, screenBits.bounds.right-8, screenBits.bounds.bottom-8);
  34.  
  35.     /* Initialize the standard window size rectangle */
  36.     SetRect(&standardRect, 60, 80, STANDARDWINDOWWIDTH+60, STANDARDWINDOWHEIGHT+80);
  37.  
  38.     /* Create and display the first task window */
  39.     if (!(newWindow = NewWindow(0L, &standardRect, "\pKevo Task", TRUE, 
  40.         documentProc+8, (WindowPtr)-1, TRUE, 0L))) {
  41.         fprintf(confile, "Could not allocate new window.\n");
  42.         fprintf(confile, "Cannot continue. Exiting.\n");
  43.         exit(1);
  44.     }
  45.  
  46.     /* Set the standard size of the window for zooming */
  47.     wDataHdl = (WStateData**)((WindowPeek)newWindow)->dataHandle;
  48.     BlockMove(&standardRect, &(*wDataHdl)->stdState, sizeof(Rect));
  49.  
  50.     /* Prepare to build a new TE (TextEdit) for the newly created window */
  51.       GetPort(&savePort);
  52.     SetPort(newWindow);
  53.  
  54.     /* Initial text settings */
  55.     TextFont(monaco);
  56.     TextFace(0);
  57.     TextSize(9);
  58.  
  59.     /* Set the view and destination rectangles for the TE */
  60.     BlockMove(&newWindow->portRect, &viewRect, sizeof(Rect));
  61.         viewRect.right  -= SCROLLBARWIDTH;
  62.         viewRect.bottom -= SCROLLBARWIDTH;
  63.     BlockMove(&newWindow->portRect, &destRect, sizeof(Rect));
  64.         destRect.right  -= (SCROLLBARWIDTH + 4);
  65.         destRect.bottom -= (SCROLLBARWIDTH + 4);
  66.         destRect.left   += 4;
  67.     
  68.     /* Allocate the TextEdit */
  69.     newText = TENew(&destRect, &viewRect);
  70.     if (!newText) {
  71.         fprintf(confile, "Could not allocate new TextEdit.\n");
  72.         fprintf(confile, "Cannot continue. Exiting.\n");
  73.         exit(1);
  74.     }
  75.  
  76.     SetPort(savePort);
  77.  
  78.     /* Set automatic scrolling */
  79.     TEAutoView(TRUE, newText);
  80.  
  81.     /* Create a window information structure for the TextEdit window */
  82.     newWinfo = createWinfo(TEWKind, newText);
  83.  
  84.     /* Then set the RefCon field of the new window to point to the winfo struct */
  85.     SetWRefCon(newWindow, (long)newWinfo);
  86.     
  87.     /* Assign the new window to the current task */
  88.     (*up)->window = (int*)newWindow;
  89.     
  90.     /* Initialize the UI pointers to the currently user-chosen task and TE */
  91.     theText = newText;
  92.     theTask = up;
  93.  
  94.     /* Receive text from clipboard, and activate the TE */
  95.     TEFromScrap();
  96.     TEActivate(theText);
  97.  
  98.     /* Initialize the information for CUTting, COPYing, and PASTEing objects */
  99.     ClipObject = NIL;
  100.     ClipList = createList();
  101.     ClipContext = copyContext(dummyContext);
  102.     ClipMode = CLIP_COPY;
  103.  
  104.     /* Initialize menus and set the correct display mode */
  105.     initMenus();
  106.     doChangeGUIMode(TEWKind);
  107.  
  108.     SelectWindow(newWindow);
  109.     aboutKevo();
  110.     
  111.     /* Initialize the deadlock detection variable */
  112.     lastEventTime = TickCount();
  113.     
  114. #ifdef UNIX
  115.     /* Initialize the Curses library */
  116.       /* Ensure that input characters will be not echoed */
  117.       /* Set character at a time input mode */
  118.  
  119.     initscr();    
  120.       noecho();    
  121.       cbreak();
  122. #endif
  123. }
  124.  
  125.  
  126. /* Initialize menus by reading them from the resource file */
  127.  
  128. void initMenus()
  129. {
  130.     appleMenu = GetMenu(APPLE_MENU);
  131.     AddResMenu(appleMenu, 'DRVR');
  132.  
  133.       fileMenu         = GetMenu(FILE_MENU);
  134.  
  135.     edit1Menu         = GetMenu(EDIT1_MENU);
  136.     tasksMenu         = GetMenu(TASKS_MENU);
  137.     multitaskMenu     = GetMenu(MULTITASK_MENU);
  138.     debugMenu         = GetMenu(DEBUG_MENU);
  139.  
  140.     edit2Menu        = GetMenu(EDIT2_MENU);
  141.     viewMenu         = GetMenu(VIEW_MENU);
  142.     toolsMenu        = GetMenu(TOOLS_MENU);
  143.     /* propagationMenu = GetMenu(PROPAGATION_MENU); */
  144.  
  145.     windowMenu        = NewMenu(WINDOW_MENU, "\pWindows");
  146. }
  147.  
  148.  
  149. /* Display the 'about' box */
  150.  
  151. void aboutKevo()
  152. {
  153.     EventRecord    mouseEvent;
  154.     DialogPtr    theDialog;
  155.     GrafPtr        savePort;
  156.     
  157.     GetPort(&savePort);        /* save current GrafPort */
  158.  
  159.     /* get dialog ptr from resource file */
  160.     if (theDialog = GetNewDialog (ABOUT_DIALOG, 0, (WindowPtr)-1)) {
  161.  
  162.         /* Now make it visible */
  163.         ShowHide (theDialog, TRUE);
  164.         DrawDialog(theDialog);
  165.  
  166.         while(!WaitNextEvent(mDownMask + keyDownMask, &mouseEvent, eventSlice, 0L));
  167.         DisposDialog(theDialog);
  168.     }
  169.     else {
  170.         SysBeep (1);
  171.         fprintf(confile, "== About window is not available (check resource fork) ==\n");
  172.     }
  173.     
  174.     SetPort(savePort);        /* restore saved GrafPort */
  175. }
  176.  
  177.  
  178. /*---------------------------------------------------------------------------*/
  179. /* Event loop */
  180.  
  181. /* 
  182.     The following routine defines the Macintosh-specific event loop. 
  183.     This routine takes care of responding to mouse, keyboard, etc. events
  184.     coming from the user.
  185.  
  186.     Note that in Kevo the event loop is not actually a loop, but it is 
  187.     a piece of code which is called frequently from the task switching 
  188.     operation 'yield()' (see kernel.c). This strategy has been chosen
  189.     because in Kevo the heart of the system is the inner interpreter --
  190.     not the event loop.
  191. */
  192.  
  193. void EventLoop()
  194. {
  195.     /* 
  196.         Do not poll events when executing critical regions.
  197.         This is important, because otherwise the user might activate
  198.         task switching and change multitasking settings from the user interface 
  199.         even when critical regions are being executed.
  200.  
  201.         However, if the event loop will has not been invoked for 20 seconds
  202.         (1200 Mac clock ticks), the protected region will be unlocked by force
  203.         in order to avoid unterminating loops.
  204.     */ 
  205.     if (inProtRegion) {
  206.         if (TickCount() - lastEventTime < 1200) return;     
  207.         fprintf(confile, "== Critical region unlocked by the system (deadlock suspected) ==\n"); 
  208.         inProtRegion = 0;
  209.         multitasking = mtStore;
  210.         SysBeep(1); SysBeep(1);
  211.     }
  212.  
  213.     /* 
  214.         Set the supervisor mode on so as to prevent tasks from being affected
  215.         by possible errors resulting from commands given from the user interface.
  216.     */ 
  217.     supervisor = TRUE;
  218.     lastEventTime = TickCount();
  219.  
  220.     /* Blink the text cursor */
  221.     if (theText) TEIdle(theText);
  222.  
  223.      if (WaitNextEvent (everyEvent, &theEvent, eventSlice, 0L)) {
  224.         switch (theEvent.what) {
  225.             case keyDown:
  226.             case autoKey:
  227.                 doKeyEvent();
  228.                 break;
  229.             case mouseDown:
  230.                 doMouseEvent();
  231.                 break;
  232.             case updateEvt:
  233.                  doUpdateEvent(); 
  234.                 break;
  235.             case activateEvt:
  236.                  doActivateEvent(); 
  237.                 break;
  238.             case app4Evt:
  239.                 doSuspendResume();
  240.                 break;
  241.         }
  242.      }
  243.      
  244.      /* Calculate the next time when event loop should be invoked */
  245.     nextTime = TickCount() + eventDelay;
  246.         
  247.     supervisor = FALSE;
  248.  
  249.     /* Set the correct multitasking mode (see 'doMenuItem()') */
  250.     doFlags();
  251. }
  252.  
  253.  
  254. /* Some keyboard key was pressed */
  255.  
  256. void doKeyEvent()
  257. {
  258.   char c = theEvent.message & charCodeMask;
  259.  
  260.     if (theEvent.modifiers & cmdKey) { /* Menu command key */
  261.         /* Ensure that extra menu key shortcuts will be disabled */
  262.         doMenuDisable();        
  263.         doMenuItem(MenuKey(c));
  264.     }
  265.     else {
  266.         switch (GUIMode) {
  267.             case GUIShell:
  268.                 /* Does current window have a TE? */
  269.                 /* If so, put the char to the active TE */
  270.                 if (theText) TEKey(c, theText);
  271.     
  272.                 /* If the window has an associated task, put char to its text buffer. */
  273.                 if (theTask) {    
  274.                     /* Return chars are put twice to the buffer */
  275.                     /* This is because our parser needs two separators between lines */
  276.                     if (c == CR) putToKeyBuffer(theTask, CR);
  277.                     if (c >= BL || c == CR) putToKeyBuffer(theTask, c);
  278.                     else if (c == BS) removeFromKeyBuffer(theTask);
  279.                 }
  280.                 break;
  281.             
  282.             case GUIBrowser: {
  283.                 /* Handle the renaming of properties */
  284.                 WindowPtr  browserWindow = FrontWindow();
  285.                 ListHandle iconList   = getBrowserIcons(browserWindow);
  286.                 Cell        cell       = LLastClick(iconList);
  287.  
  288.                 if (cell.h >= 0 && cell.v >= 0 && LGetSelect(FALSE, &cell, iconList)) {
  289.                     /* Some cell is currently selected */
  290.                     if (c == BS) removeFromCell(iconList, cell);
  291.                     else if (c == CR) renameCell(browserWindow, cell);
  292.                     else if (c == BL) SysBeep(1); 
  293.                     else addToCell(iconList, cell, c);
  294.                 }
  295.                 else SysBeep(1);
  296.                 break;
  297.             }
  298.         }
  299.     }
  300. }
  301.  
  302.  
  303. /* Mouse key was pressed */
  304.  
  305. void doMouseEvent()
  306. {
  307.   WindowPtr        mouseWindow;
  308.   short         location;
  309.  
  310.     location = FindWindow(theEvent.where, &mouseWindow);
  311.     
  312.     switch (location)
  313.     {
  314.         case inDesk:
  315.             break;
  316.             
  317.         case inMenuBar:
  318.             doMenuDisable();
  319.             doMenuMarkers();
  320.             doMenuItem(MenuSelect(theEvent.where));
  321.             break;
  322.             
  323.         case inSysWindow:
  324.             SystemClick(&theEvent, mouseWindow);
  325.             break;
  326.             
  327.         case inContent:
  328.             if (mouseWindow != FrontWindow() || !((WindowPeek)mouseWindow)->hilited) {
  329.                 /* Select another Kevo window */
  330.                 SelectWindow(mouseWindow);
  331.             }
  332.             else {
  333.                 short             controlCode;
  334.                 ControlHandle     theControl;
  335.                 
  336.                 GlobalToLocal(&theEvent.where);
  337.             
  338.                 if (controlCode = FindControl(theEvent.where, mouseWindow, &theControl)) {
  339.                     /* Mouse clicked in a control */
  340.                     if (controlCode == inThumb) doThumb(mouseWindow, theControl, controlCode);
  341.                     else TrackControl(theControl, theEvent.where, doWindowControls);
  342.                 }
  343.                 else {
  344.                     /* Mouse clicked outside any control -> */
  345.                     /* Pass the mouse click to the current window */
  346.                     doWindowClick(mouseWindow);
  347.                 }
  348.             }
  349.             break;            
  350.  
  351.         case inDrag:
  352.             SelectWindow(mouseWindow);
  353.             DragWindow(mouseWindow, theEvent.where, &limitRect);
  354.             break;
  355.  
  356.         case inGrow: {
  357.             long growResult = GrowWindow(mouseWindow, theEvent.where, &limitRect);
  358.             if (growResult != 0) {
  359.                   GrafPtr    savePort;
  360.                   GetPort(&savePort);
  361.                   SetPort(mouseWindow);
  362.                 SizeWindow(mouseWindow, LoWord(growResult), HiWord(growResult), TRUE);
  363.                 doResizeWindow(mouseWindow, LoWord(growResult), HiWord(growResult));
  364.                 DrawGrowIcon(mouseWindow);
  365.                 SetPort(savePort);
  366.             }
  367.             break;
  368.         }
  369.  
  370.         case inZoomIn:
  371.         case inZoomOut:
  372.             if (TrackBox(mouseWindow, theEvent.where, location))
  373.                 doZoomWindow(mouseWindow, location);
  374.             break;
  375.  
  376.         case inGoAway:
  377.             if (TrackGoAway(mouseWindow, theEvent.where)) doCloseWindow(mouseWindow);
  378.             break;
  379.     }
  380. }
  381.                 
  382.  
  383. /* A window needs to be updated */
  384.  
  385. void doUpdateEvent()
  386. {
  387.   WindowPtr        thisWindow = (WindowPtr)theEvent.message;
  388.   int            wKind = getWindowKind(thisWindow);
  389.   GrafPtr        savePort;
  390.   
  391.     /* Update a window, but only if it belongs to Kevo */
  392.     if (((WindowPeek)thisWindow)->windowKind == userKind) {     
  393.         GetPort(&savePort);
  394.         SetPort(thisWindow);
  395.         BeginUpdate(thisWindow);
  396.         
  397.         switch (wKind) {
  398.             case PlainWKind:
  399.                 /* xxx Some vectored routine should be put here */
  400.                 /* to allow updating of graphics windows etc. */
  401.                 break;
  402.             case TEWKind: {
  403.                  TEHandle thisTE;
  404.                 if (thisTE = getWindowTE(thisWindow)) {
  405.                     EraseRect(&(*thisTE)->viewRect);
  406.                     TEUpdate(&(*thisTE)->viewRect, thisTE);
  407.                 }
  408.                 break;
  409.             }
  410.             case BrowserWKind: 
  411.             case CloneBrWKind:
  412.             {
  413.                 /* Redraw all the visible browser icons (cells) */
  414.  
  415.                 ListHandle iconList = getBrowserIcons(thisWindow);
  416.                 if (iconList) {
  417.                     EraseRect(&thisWindow->portRect);
  418.                     LUpdate(thisWindow->visRgn, iconList);
  419.                 }    
  420.                 break;
  421.             }
  422.         }        
  423.         DrawGrowIcon(thisWindow);
  424.  
  425.         EndUpdate(thisWindow);
  426.         SetPort(savePort);
  427.     }
  428. }
  429.  
  430.  
  431. /* A window is changed from active to passive, or vice versa */
  432.  
  433. void doActivateEvent()
  434. {
  435.   WindowPtr    thisWindow = (WindowPtr)theEvent.message;
  436.   int        wKind = getWindowKind(thisWindow);
  437.  
  438.       SetPort(thisWindow);
  439.       
  440.     if (theEvent.modifiers & activeFlag) {
  441.         /* The window is activated */
  442.     
  443.         theTask = determineTask(thisWindow);
  444.  
  445.         switch (wKind) {
  446.             case PlainWKind:
  447.                 theText = NIL;
  448.                 break;
  449.         
  450.             case TEWKind: {
  451.                 TEHandle thisTE;
  452.                 if (thisTE = getWindowTE(thisWindow)) {
  453.                     TEActivate(thisTE);
  454.                     theText = thisTE;
  455.                 }    
  456.                 break;
  457.             }
  458.             case BrowserWKind: 
  459.             case CloneBrWKind:
  460.             {
  461.                 ListHandle iconList = getBrowserIcons(thisWindow);
  462.                 if (iconList) LActivate(TRUE, iconList);
  463.                 updateBrowser(thisWindow);
  464.                 theText = NIL;
  465.                 break;
  466.             }
  467.         }
  468.  
  469.         /* If singletasking, change the currently executing task */
  470.         if (!multitasking) doSelectTask(thisWindow, theTask);
  471.  
  472.         /* Set the appropriate GUI mode (change menus if needed) */
  473.         doChangeGUIMode(wKind);    
  474.  
  475.         InitCursor();        /* Ensure that we have the correct mouse cursor */
  476.     }
  477.     else {
  478.         TEHandle thisTE;
  479.         
  480.         /* The window is passivated */
  481.         theTask = NIL;
  482.  
  483.         switch (wKind) {
  484.             case PlainWKind:
  485.             case TEWKind:
  486.                 if (thisTE = getWindowTE(thisWindow)) TEDeactivate(thisTE); 
  487.                 break;
  488.             case BrowserWKind: 
  489.             case CloneBrWKind:
  490.             {
  491.                 ListHandle iconList = getBrowserIcons(thisWindow);
  492.                 if (iconList) LActivate(FALSE, iconList);
  493.                 break;
  494.             }
  495.         }
  496.     }
  497.  
  498.     DrawGrowIcon((WindowPtr)theEvent.message);
  499. }
  500.  
  501.  
  502. /* The Kevo system becomes suspended or resumed by the Mac OS */
  503. /* Suspended = moved from foreground to background. */
  504. /* Resumed   = moved from background to foreground. */
  505.  
  506. void doSuspendResume()
  507. {
  508.     int            activate;
  509.     WindowPtr    mouseWindow = FrontWindow();
  510.     
  511.     /* Suspend == false, Resume == true */
  512.     activate = (theEvent.message & 1) ? TRUE : FALSE;
  513.     
  514.     if (((WindowPeek)mouseWindow)->windowKind == userKind) {
  515.         /* Activate/deactivate */
  516.         if (activate) {
  517.             SelectWindow(mouseWindow);
  518.             HiliteWindow(mouseWindow, TRUE);
  519.             TEFromScrap();
  520.             InitCursor();    /* Ensure that we have the correct mouse cursor */
  521.         }
  522.         else {
  523.             HiliteWindow(mouseWindow, FALSE);
  524.  
  525.             /* Copy the contents of TE scrap to the clipboard */
  526.             /* so that other applications can use our clipboard contents */
  527.             ZeroScrap();
  528.             TEToScrap();
  529.         }
  530.     }
  531. }
  532.  
  533.  
  534. /* Pass a mouse click to a window */
  535.  
  536. void doWindowClick(thisWindow)
  537. WindowPtr thisWindow;
  538. {
  539.     /* Note that by now 'theEvent.where' must have been converted to local coordinates */  
  540.  
  541.     switch (getWindowKind(thisWindow)) {
  542.         case PlainWKind:
  543.         case TEWKind:
  544.             /* Pass the mouse click to the current window */
  545.             if (theText) {
  546.                 if (PtInRect(theEvent.where, &(*theText)->viewRect)) 
  547.                     TEClick(theEvent.where, theEvent.modifiers & shiftKey, theText);
  548.             }
  549.             break;
  550.  
  551.         case BrowserWKind: 
  552.         case CloneBrWKind:
  553.         {
  554.             ListHandle iconList = getBrowserIcons(thisWindow);
  555.             
  556.             if (iconList) {
  557.               int doubleClick;
  558.               int optKey = theEvent.modifiers & optionKey;
  559.               
  560.                 if (PtInRect(theEvent.where, &(*iconList)->rView))
  561.                     doubleClick = LClick(theEvent.where, theEvent.modifiers, iconList);
  562.  
  563.                 if (doubleClick) handleDoubleClick(thisWindow, optKey);
  564.             }
  565.             break;
  566.         }
  567.     }
  568. }
  569.  
  570.  
  571. /* Operate the window controls (scroll bars, etc.) */
  572. /* 
  573.     This routine is called by Mac Toolbox routine 'TrackControl' so
  574.     it must be declared a Pascal routine.
  575. */
  576.  
  577. pascal void doWindowControls(theControl, controlCode)
  578. ControlHandle     theControl;
  579. short             controlCode;
  580. {
  581.   WindowPtr thisWindow = FrontWindow();
  582.  
  583.     switch(getWindowKind(thisWindow)) {
  584.         case PlainWKind:
  585.         case TEWKind:
  586.             /* In the current implementation, only browser windows have scroll bars */
  587.             break;
  588.         case BrowserWKind: 
  589.         case CloneBrWKind:
  590.         {
  591.             ListHandle iconList = getBrowserIcons(thisWindow);
  592.             int vertical   = (theControl == ((*iconList)->vScroll));
  593.             int horizontal = (theControl == ((*iconList)->hScroll));
  594.             
  595.             switch (controlCode) {
  596.                 case inUpButton:
  597.                     if (vertical)     LScroll(0, -1, iconList);
  598.                     if (horizontal) LScroll(-1, 0, iconList);
  599.                     break;
  600.                 case inDownButton:
  601.                     if (vertical)     LScroll(0, 1, iconList);
  602.                     if (horizontal) LScroll(1, 0, iconList);
  603.                     break;
  604.                 case inPageUp:
  605.                     if (vertical)     LScroll(0, -15, iconList);
  606.                     if (horizontal) LScroll(-4, 0, iconList);
  607.                     break;
  608.                 case inPageDown:
  609.                     if (vertical)     LScroll(0, 15, iconList);
  610.                     if (horizontal) LScroll(4, 0, iconList);
  611.                     break;
  612.             }
  613.         }
  614.     }
  615. }
  616.  
  617.  
  618. /* Operate a scroll bar thumb */
  619. /* In the current implementation, only browser windows can have scroll bars */
  620.  
  621. void doThumb(thisWindow, theControl, controlCode)
  622. WindowPtr        thisWindow;
  623. ControlHandle    theControl;
  624. short            controlCode;
  625. { 
  626.   ListHandle iconList = getBrowserIcons(thisWindow);
  627.   int vertical   = (theControl == ((*iconList)->vScroll));
  628.   int horizontal = (theControl == ((*iconList)->hScroll));
  629.   int beginValue;
  630.   int endValue;
  631.  
  632.     beginValue = GetCtlValue(theControl);
  633.     TrackControl(theControl, theEvent.where, NIL);
  634.     endValue   = GetCtlValue(theControl);
  635.     
  636.     if (vertical)     LScroll(0, endValue-beginValue, iconList);
  637.     if (horizontal) LScroll(endValue-beginValue, 0, iconList);
  638. }
  639.                              
  640.  
  641. /* Resize window contents (invoked when the size of a window is changed) */
  642.  
  643. void doResizeWindow(thisWindow, newSizeH, newSizeV)
  644. WindowPtr    thisWindow;
  645. short        newSizeH;
  646. short        newSizeV;
  647. {
  648.     int wKind = getWindowKind(thisWindow);
  649.     
  650.     EraseRect(&thisWindow->portRect);
  651.     InvalRect(&thisWindow->portRect);
  652.  
  653.     switch (wKind) {
  654.         case PlainWKind:
  655.         case TEWKind:
  656.             /* see 'portWindow.c' */
  657.             resizeWindowTE(thisWindow);
  658.             break;
  659.  
  660.         case BrowserWKind: 
  661.         case CloneBrWKind:
  662.         {
  663.             ListHandle iconList = getBrowserIcons(thisWindow);
  664.             LSize(newSizeH-15, newSizeV-15, iconList); 
  665.             break;
  666.         }
  667.     }
  668. }
  669.  
  670.  
  671. /* Zoom the window to the standard size */
  672.  
  673. void doZoomWindow(thisWindow, partCode)
  674. WindowPtr thisWindow;
  675. short      partCode;
  676. {
  677.   GrafPtr    savePort;
  678.   int        wKind = getWindowKind(thisWindow);
  679.  
  680.     GetPort(&savePort);
  681.     SetPort(thisWindow);
  682.  
  683.     /* Browser window size can be determined automatically */
  684.     if (wKind == BrowserWKind || wKind == CloneBrWKind)
  685.         determineBrowserWindowSize(thisWindow);
  686.     else {
  687.       int offsetLeft = 0 - thisWindow->portBits.bounds.left;
  688.       int offsetTop  = 0 - thisWindow->portBits.bounds.top;
  689.       WStateData** wDataHdl;
  690.       Rect newRect;
  691.  
  692.         /* Automatically calculate the correct browser size for zooming */
  693.         SetRect(&newRect, offsetLeft, offsetTop, 
  694.                 offsetLeft + STANDARDWINDOWWIDTH, 
  695.                 offsetTop  + STANDARDWINDOWHEIGHT);
  696.         wDataHdl = (WStateData**)((WindowPeek)thisWindow)->dataHandle;
  697.         BlockMove(&newRect, &(*wDataHdl)->stdState, sizeof(Rect));
  698.     }
  699.  
  700.     ZoomWindow(thisWindow, partCode, FALSE);
  701.     doResizeWindow(thisWindow, thisWindow->portRect.right, thisWindow->portRect.bottom);
  702.  
  703.     SetPort(savePort);
  704. }
  705.  
  706.  
  707. /* Close a window */
  708.  
  709. void doCloseWindow(thisWindow)
  710. WindowPtr thisWindow;
  711. {
  712.   int wKind;
  713.  
  714.     if (countVisibleWindows() <= 1) {
  715.         fprintf(confile, "== Cannot close the only visible window in the system ==\n");
  716.         return;
  717.     }
  718.  
  719.     switch (wKind = getWindowKind(thisWindow)) {
  720.         case PlainWKind:
  721.             /* see 'portWindows.c' */
  722.             deleteWindow(thisWindow);
  723.             break;
  724.  
  725.         case TEWKind:
  726.             if (getMethodContext(thisWindow)) {
  727.                 /* see 'portBrowser.c' */
  728.                 redefineMethod(thisWindow);
  729.             }    
  730.             deleteWindow(thisWindow);
  731.             break;
  732.             
  733.         case BrowserWKind: 
  734.         case CloneBrWKind:
  735.         {
  736.             /* see 'portBrowser.c' */
  737.             deleteBrowser(thisWindow);
  738.             break;
  739.         }
  740.     }
  741. }
  742.  
  743.  
  744. /* Change execution mode on the basis of flags set by 'doMenuItem()' */
  745.  
  746. void doFlags()
  747. {
  748.     if (cooperativeFlag) {
  749.         if (cooperativeFlag > 0) {
  750.             if (multitasking) 
  751.                   fprintf(confile, "== Cooperative multitasker active ==\n");
  752.             else fprintf(confile, "== Cooperative singletasker active ==\n");
  753.  
  754.             cooperativeFlag = 0;
  755.             pCooperative();
  756.         }
  757.         else {
  758.             if (multitasking) 
  759.                   fprintf(confile, "== Preemptive multitasker active ==\n");
  760.             else fprintf(confile, "== Preemptive singletasker active ==\n"); 
  761.  
  762.             cooperativeFlag = 0;
  763.             pPreemptive();
  764.         }
  765.     }
  766.     
  767.     if (traceFlag) {
  768.         if (traceFlag == TRACE) {
  769.             traceFlag = 0;
  770.             traceInterpreter();
  771.         }
  772.         else if (traceFlag == FULLTRACE) {
  773.             traceFlag = 0;
  774.             fullTraceInterpreter();
  775.         }
  776.         else {
  777.             traceFlag = 0;
  778.             ownLongJmp();
  779.         }
  780.     }
  781. }
  782.  
  783.  
  784. /* 
  785.     In singletasking mode, selecting a window causes the (possible) task
  786.     in the selected window to run. This operation takes care of yielding 
  787.     the control to the correct task.
  788.  
  789.     'thisTask' is passed as a parameter so that we don't necessarily have to 
  790.     run 'determineTask'.
  791. */
  792. void doSelectTask(thisWindow, thisTask)
  793. int            thisWindow;
  794. TASK**        thisTask;
  795. {
  796.       /* We may not interrupt the execution of a protected region */
  797.     /* if (inProtRegion) return; */
  798.     
  799.     switch (getWindowKind(thisWindow)) {
  800.         case PlainWKind:
  801.         case TEWKind:
  802.             if (thisTask && isActivated(thisTask)) yieldTo(thisTask);
  803.             break;
  804.                 
  805.         case BrowserWKind: 
  806.         case CloneBrWKind:
  807.         {
  808.             if (browserTask && isActivated(browserTask)) yieldTo(browserTask);
  809.             break;
  810.         }
  811.     }
  812. }
  813.  
  814.  
  815. /* Set the appropriate GUI mode, changing the menus if needed */
  816. /* The possible modes are:
  817.         GUIShell:    the normal execution environment
  818.         GUIBrowser:    object browser
  819. */
  820.  
  821. void doChangeGUIMode(newWKind)
  822. int        newWKind;
  823. {
  824.     if (newWKind == PlainWKind || newWKind == TEWKind) {
  825.     
  826.         /* Enable these menus so as to ensure that they will be displayed */
  827.         EnableItem(tasksMenu, 0);
  828.         EnableItem(debugMenu, SET_BREAK_MENUITEM);
  829.         EnableItem(debugMenu, REMOVE_BREAK_MENUITEM);
  830.         if (!theTask) 
  831.              DisableItem(edit1Menu, BROWSE_MENUITEM);
  832.         else EnableItem(edit1Menu, BROWSE_MENUITEM);
  833.  
  834.         if (GUIMode != GUIShell) {
  835.  
  836.             /* Remove the previous menus */
  837.             ClearMenuBar();
  838.             
  839.             InsertMenu(appleMenu, 0);
  840.             InsertMenu(fileMenu, 0);
  841.             InsertMenu(edit1Menu, 0);
  842.             InsertMenu(tasksMenu, 0);
  843.             InsertMenu(debugMenu, 0);
  844.             InsertMenu(multitaskMenu, 0);
  845.             InsertMenu(windowMenu, 0);
  846.  
  847.             DisableItem(fileMenu, SAVE_IMAGE_MENUITEM);
  848.     
  849.             DrawMenuBar();
  850.  
  851.             GUIMode = GUIShell;
  852.         }
  853.         else DrawMenuBar();
  854.         return;
  855.     }
  856.     
  857.     if (newWKind == BrowserWKind || newWKind == CloneBrWKind) {
  858.  
  859.         /* Enable these menus so as to ensure that they will be displayed */
  860.         EnableItem(viewMenu, 0);
  861.         EnableItem(toolsMenu, 0);
  862.         EnableItem(edit2Menu, 0);        
  863.         EnableItem(edit2Menu, MKDIR_MENUITEM);
  864.         EnableItem(edit2Menu, ADD_VAR_MENUITEM);
  865.         EnableItem(edit2Menu, ADD_SHAREDVAR_MENUITEM);
  866.         EnableItem(edit2Menu, ADD_METHOD_MENUITEM);
  867.         EnableItem(edit2Menu, HIDE_SHOW_MENUITEM);
  868.         EnableItem(edit2Menu, THIS_ONLY_MENUITEM);
  869.         EnableItem(edit2Menu, WHOLE_FAMILY_MENUITEM);
  870.         EnableItem(edit2Menu, DERIVATIVES_MENUITEM);
  871.  
  872.         if (GUIMode != GUIBrowser) {
  873.  
  874.             /* Remove the previous menus */
  875.             ClearMenuBar();
  876.             
  877.             InsertMenu(appleMenu, 0);
  878.             InsertMenu(fileMenu, 0);
  879.             InsertMenu(edit2Menu, 0);
  880.             InsertMenu(viewMenu, 0);
  881.             InsertMenu(toolsMenu, 0);
  882.             InsertMenu(multitaskMenu, 0);
  883.             InsertMenu(windowMenu, 0);
  884.  
  885.             /* UNDO has not been implemented in the browser */
  886.             DisableItem(edit2Menu, UNDO_MENUITEM);
  887.  
  888.             DrawMenuBar();
  889.  
  890.             GUIMode = GUIBrowser;
  891.         }
  892.         else DrawMenuBar();
  893.         return;
  894.     }
  895. }
  896.  
  897.  
  898. /* Disable appropriate menu items */
  899.  
  900. void doMenuDisable()
  901. {
  902.     /* Do general disabling/enabling operations */
  903.     doConsoleDisable();
  904.     doBrowserDisable();
  905.  
  906.     /* Do menu-specific disabling/enabling */
  907.     doDebugMenuDisable();
  908. }    
  909.     
  910.  
  911. /* 
  912.     Disable certain menu items if the console window 
  913.     or a transcript window is selected. This can be known
  914.     by checking 'theTask' and the window kind of the frontmost window.
  915. */
  916. void doConsoleDisable()
  917. {
  918.   WindowPtr thisWindow = FrontWindow();
  919.   int wKind = getWindowKind(thisWindow);
  920.  
  921.     /* Window has no associated task -> disable certain menu items */
  922.     if (!theTask && wKind != BrowserWKind && wKind != CloneBrWKind) {
  923.         switch (GUIMode) {
  924.             case GUIShell:    
  925.                 /* Disable all the items in context and command menus */
  926.                 DisableItem(tasksMenu, 0);
  927.                 DisableItem(debugMenu, SET_BREAK_MENUITEM);
  928.                 DisableItem(debugMenu, REMOVE_BREAK_MENUITEM);
  929.                 DisableItem(edit1Menu, BROWSE_MENUITEM);
  930.                 break;
  931.             case GUIBrowser:
  932.                 /* Disable all the items in other than file and edit menus */
  933.                 DisableItem(viewMenu, 0);
  934.                 DisableItem(toolsMenu, 0);
  935.                 DisableItem(edit2Menu, MKDIR_MENUITEM);
  936.                 DisableItem(edit2Menu, ADD_VAR_MENUITEM);
  937.                 DisableItem(edit2Menu, ADD_SHAREDVAR_MENUITEM);
  938.                 DisableItem(edit2Menu, ADD_METHOD_MENUITEM);
  939.                 DisableItem(edit2Menu, HIDE_SHOW_MENUITEM);
  940.                 DisableItem(edit2Menu, THIS_ONLY_MENUITEM);
  941.                 DisableItem(edit2Menu, WHOLE_FAMILY_MENUITEM);
  942.                 DisableItem(edit2Menu, DERIVATIVES_MENUITEM);
  943.                 break;
  944.         }
  945.     }
  946. }
  947.  
  948.  
  949. /*
  950.     Enable/disable certain menu items if we are currently in the 
  951.     browsing mode. 
  952. */
  953. void doBrowserDisable()
  954. {
  955.   WindowPtr thisWindow = FrontWindow();
  956.   int wKind = getWindowKind(thisWindow);
  957.  
  958.     /* Disable/enable family items from the view menu when browsing */
  959.     if (wKind != BrowserWKind && wKind != CloneBrWKind) return;
  960.     else { 
  961.         OBJECT* cwd        = getBrowserTarget(thisWindow);
  962.         LIST*   cwdFamily  = getContext(cwd)->cloneFamily;
  963.  
  964.  
  965.         /* Disable/enable the clone family menu item */
  966.         if (cwdFamily && cwdFamily->logicalSize > 0)
  967.              EnableItem(viewMenu, SHOW_CLONEF_MENUITEM);
  968.         else DisableItem(viewMenu, SHOW_CLONEF_MENUITEM);
  969.  
  970.  
  971.         /* Disable/enable the parent families menu item */
  972.         switch(wKind) {
  973.             case BrowserWKind:
  974.                 cwdFamily = getContext(cwd)->parentFamilies;
  975.                 break;
  976.             case CloneBrWKind:
  977.                 /* Note: this assumes that clone family has at least one member */
  978.                 cwd = fetchFromList((LIST*)getBrowserTarget(thisWindow), 1);
  979.                 cwdFamily = getContext(cwd)->parentFamilies;
  980.         }
  981.         if (cwdFamily && cwdFamily->logicalSize > 0)
  982.              EnableItem(viewMenu, SHOW_PARENTF_MENUITEM);
  983.         else DisableItem(viewMenu, SHOW_PARENTF_MENUITEM);
  984.         
  985.  
  986.         /* Disable/enable the child families menu item */
  987.         switch(wKind) {
  988.             case BrowserWKind:
  989.                 cwdFamily = getContext(cwd)->childFamilies;
  990.                 break;
  991.             case CloneBrWKind:
  992.                 /* Note: this assumes that clone family has at least one member */
  993.                 /* cwd = fetchFromList((LIST*)getBrowserTarget(thisWindow), 1); done above */
  994.                 cwdFamily = getContext(cwd)->childFamilies;
  995.                 break;
  996.         }
  997.         if (cwdFamily && cwdFamily->logicalSize > 0)
  998.              EnableItem(viewMenu, SHOW_CHILDF_MENUITEM);
  999.         else DisableItem(viewMenu, SHOW_CHILDF_MENUITEM);
  1000.  
  1001.  
  1002.         /* Editing functions are disabled when browsing a clone family */
  1003.         if (wKind == CloneBrWKind) {
  1004.             DisableItem(edit2Menu, 0);
  1005.             DisableItem(toolsMenu, 0);
  1006.         }
  1007.         else {
  1008.             /* Browsing a normal object */
  1009.             EnableItem(edit2Menu, 0);
  1010.             EnableItem(toolsMenu, 0);
  1011.  
  1012.             /* If the object responds to copying operations, enable them */
  1013.             if (respondsTo(cwd, "share")) 
  1014.                  EnableItem(toolsMenu, SHARE_MENUITEM);
  1015.             else DisableItem(toolsMenu, SHARE_MENUITEM);
  1016.  
  1017.             if (respondsTo(cwd, "clone")) 
  1018.                  EnableItem(toolsMenu, CLONE_MENUITEM);
  1019.             else DisableItem(toolsMenu, CLONE_MENUITEM);
  1020.  
  1021.             if (respondsTo(cwd, "new")) 
  1022.                  EnableItem(toolsMenu, NEW_MENUITEM);
  1023.             else DisableItem(toolsMenu, NEW_MENUITEM);
  1024.  
  1025. /* This has been removed from the menus:
  1026.             if (respondsTo(cwd, "deepCopy")) 
  1027.                  EnableItem(toolsMenu, DEEP_COPY_MENUITEM);
  1028.             else DisableItem(toolsMenu, DEEP_COPY_MENUITEM);
  1029. */
  1030.             /* If the second topmost window is not an object browser */
  1031.             /* disable assignment */
  1032.             {
  1033.                 ListHandle iconList = getBrowserIcons(thisWindow);
  1034.                 WindowPtr secondWindow = (WindowPtr)((WindowPeek)thisWindow)->nextWindow;
  1035.                 PAIR* tempPair;
  1036.  
  1037.                 if (secondWindow && getWindowKind(secondWindow) == BrowserWKind && 
  1038.                     getBrowserTarget(secondWindow) && countSelectedCells(iconList) == 1) {
  1039.                     Cell cell;
  1040.                     int pairKind;
  1041.                     
  1042.                     cell.h = -1; cell.v = 0;
  1043.                     (void)nextSelectedCell(iconList, &cell);
  1044.                     tempPair = cellToPair(thisWindow, cell);
  1045.                     if (!tempPair) goto forw; /* Array slot cannot be assigned to */
  1046.                     pairKind = recognizeObject(tempPair->ofa);
  1047.                          
  1048.                     if (pairKind == REF || pairKind == VAR) EnableItem(toolsMenu, ASSIGN_MENUITEM);
  1049.                     else goto forw;
  1050.                 }
  1051.                 else forw: DisableItem(toolsMenu, ASSIGN_MENUITEM);
  1052.             }
  1053.         }
  1054.     }
  1055. }
  1056.  
  1057.  
  1058. /* Enable/disable items in the debug menu */ 
  1059.  
  1060. void doDebugMenuDisable()
  1061. {
  1062.     /* RESUME in debug menu is enabled only when the chosen task is to be debugged */
  1063.     if (theTask && theTask == debugTask)
  1064.          EnableItem(debugMenu, RESUME_MENUITEM);
  1065.     else DisableItem(debugMenu, RESUME_MENUITEM);
  1066. }
  1067.  
  1068.  
  1069. /* Set/reset certain markers in the menu bar */
  1070. /* This must be executed when the user opens a menu */
  1071.  
  1072. void doMenuMarkers()
  1073. {
  1074.     doMultitaskMenuMark();
  1075.     doDebugMenuMark();
  1076.     doViewMenuMark();
  1077.     doEdit2MenuMark();
  1078.     doWindowMenuMark();
  1079. }
  1080.  
  1081.  
  1082. /* Change the markers in the multitasking menu */
  1083.  
  1084. void doMultitaskMenuMark()
  1085. {    
  1086.     if (multitasking)
  1087.     /* previously: (!inProtRegion && multitasking) || (inProtRegion && mtStore))  */
  1088.          SetItemMark(multitaskMenu, MON_MOFF_MENUITEM, checkMark);
  1089.     else SetItemMark(multitaskMenu, MON_MOFF_MENUITEM, noMark);
  1090.  
  1091.     switch(mtaskMode) {
  1092.         case PREEMPTIVE:
  1093.               SetItemMark(multitaskMenu, PREEMPTIVE_MENUITEM,  diamondMark);
  1094.               SetItemMark(multitaskMenu, COOPERATIVE_MENUITEM, noMark);
  1095.             break;
  1096.         case COOPERATIVE:
  1097.               SetItemMark(multitaskMenu, COOPERATIVE_MENUITEM, diamondMark);
  1098.               SetItemMark(multitaskMenu, PREEMPTIVE_MENUITEM,  noMark);
  1099.             break;
  1100.     }
  1101. }
  1102.  
  1103.  
  1104. /* Change the markers in the debugging menu */
  1105.  
  1106. void doDebugMenuMark()
  1107. {
  1108.     switch(traceMode) {
  1109.         case TRACE:
  1110.             SetItemMark(debugMenu, TRACE_MENUITEM,         diamondMark); 
  1111.             SetItemMark(debugMenu, FULLTRACE_MENUITEM,  noMark);
  1112.             SetItemMark(debugMenu, NOTRACE_MENUITEM,     noMark); 
  1113.             break;
  1114.         case FULLTRACE:
  1115.             SetItemMark(debugMenu, TRACE_MENUITEM,         noMark); 
  1116.             SetItemMark(debugMenu, FULLTRACE_MENUITEM,    diamondMark);
  1117.             SetItemMark(debugMenu, NOTRACE_MENUITEM,     noMark); 
  1118.             break;
  1119.         case NOTRACE:
  1120.             SetItemMark(debugMenu, TRACE_MENUITEM,         noMark); 
  1121.             SetItemMark(debugMenu, FULLTRACE_MENUITEM,    noMark);
  1122.             SetItemMark(debugMenu, NOTRACE_MENUITEM,     diamondMark); 
  1123.             break;
  1124.     }
  1125. }
  1126.  
  1127.  
  1128. /* Change the markers in the view menu */
  1129.  
  1130. void doViewMenuMark()
  1131. {
  1132.   WindowPtr thisWindow = FrontWindow();
  1133.   ListHandle iconList;
  1134.  
  1135.     if (GUIMode == GUIBrowser && (iconList = getBrowserIcons(thisWindow))) {
  1136.         int columns = ((*iconList)->dataBounds).right;
  1137.         int viewMode = getViewMode(iconList);
  1138.         
  1139.         SetItemMark(viewMenu, ONE_COLUMN_MENUITEM,      noMark);
  1140.         SetItemMark(viewMenu, FOUR_COLUMNS_MENUITEM, noMark);
  1141.  
  1142.         SetItemMark(viewMenu, VIEW_OPER_MENUITEM, noMark);
  1143.         SetItemMark(viewMenu, VIEW_DATA_MENUITEM, noMark);
  1144.         SetItemMark(viewMenu, VIEW_BOTH_MENUITEM, noMark);
  1145.  
  1146.         if (columns == 1) 
  1147.              SetItemMark(viewMenu, ONE_COLUMN_MENUITEM,   diamondMark);
  1148.         else SetItemMark(viewMenu, FOUR_COLUMNS_MENUITEM, diamondMark);
  1149.  
  1150.         switch (viewMode) {
  1151.             case ALL: 
  1152.                 SetItemMark(viewMenu, VIEW_BOTH_MENUITEM, diamondMark);
  1153.                 break;
  1154.             case DATA:
  1155.                 SetItemMark(viewMenu, VIEW_DATA_MENUITEM, diamondMark);
  1156.                 break;
  1157.             case BEHAVIOR:
  1158.                 SetItemMark(viewMenu, VIEW_OPER_MENUITEM, diamondMark);
  1159.                 break;
  1160.         }
  1161.     }
  1162. }
  1163.  
  1164.  
  1165. /* Change the markers in the edit2 menu */
  1166.  
  1167. void doEdit2MenuMark()
  1168. {
  1169.     if (GUIMode != GUIBrowser) return;
  1170.     
  1171.     SetItemMark(edit2Menu, THIS_ONLY_MENUITEM,     noMark);
  1172.     SetItemMark(edit2Menu, WHOLE_FAMILY_MENUITEM, noMark);
  1173.     SetItemMark(edit2Menu, DERIVATIVES_MENUITEM, noMark);
  1174.  
  1175.     switch (whoToModify) {
  1176.         case THIS_ONLY:
  1177.             SetItemMark(edit2Menu, THIS_ONLY_MENUITEM, diamondMark);
  1178.             break;
  1179.         case WHOLE_FAMILY:
  1180.             SetItemMark(edit2Menu, WHOLE_FAMILY_MENUITEM, diamondMark);
  1181.             break;
  1182.         case DERIVATIVES:
  1183.             SetItemMark(edit2Menu, DERIVATIVES_MENUITEM, diamondMark);
  1184.             break;
  1185.     }
  1186. }
  1187.  
  1188.  
  1189. /* Change the contents of the window menu on the basis of Mac's window list */
  1190. /*
  1191.     Note that if you add any command key shortcuts to the window menu 
  1192.     then this operation should be called by 'doMenuDisable()' rather than
  1193.     'doMenuMarkers'.
  1194. */
  1195. void doWindowMenuMark()
  1196. {
  1197.   WindowPtr thisWindow = FrontWindow();
  1198.   short windowKind;
  1199.   short count;
  1200.   
  1201.       /* Empty the possible previous contents of the window menu */
  1202.     count = CountMItems(windowMenu);
  1203.     while (count) DelMenuItem(windowMenu, count--);
  1204.  
  1205.     /* Enable/disable window hiding and move behind operations */
  1206.     if (countVisibleWindows() > 1)
  1207.          AppendMenu(windowMenu, "\pHide;Move Behind;(-");
  1208.     else AppendMenu(windowMenu, "\p(Hide;(Move Behind;(-");
  1209.  
  1210.     /* Enable/disable the 'close browsers' operation */
  1211.     if (browserCount > 0 && runningCount > 1)
  1212.          AppendMenu(windowMenu, "\pClose Browsers;(-");
  1213.     else AppendMenu(windowMenu, "\p(Close Browsers;(-");
  1214.  
  1215.     /* The menu contains five items before the window names */
  1216.     count = 5;
  1217.  
  1218.     /* Show the titles of the windows in the menu */
  1219.     /* The hidden window will be denoted with a */
  1220.     /* diamond mark in front of the menu items */
  1221.       while (thisWindow) {
  1222.           count++;
  1223.         GetWTitle(thisWindow, (Str255*)charbuffer);          
  1224.         /* Remove the possible meta characters from the window name */
  1225.         replaceMenuMetas(charbuffer);
  1226.         AppendMenu(windowMenu, (Str255*)charbuffer); 
  1227.         if (!((WindowPeek)thisWindow)->visible) 
  1228.             SetItemMark(windowMenu, count, 215); /* 215 = open diamond mark */
  1229.         thisWindow = (WindowPtr)((WindowPeek)thisWindow)->nextWindow;
  1230.     }
  1231. }
  1232.  
  1233.  
  1234. /* Standard error message for 'doMenuItem()' */
  1235. void noActiveTask()
  1236. {
  1237.     fprintf(confile, "== The current window has no active task to carry out the operation ==\n");
  1238. }
  1239.  
  1240.  
  1241. /* Select an item from the menu */
  1242.  
  1243. void doMenuItem(menuresult)
  1244. long menuresult;
  1245. {
  1246.   short menuId, itemNumber;
  1247.   
  1248.       menuId = HiWord(menuresult);
  1249.       itemNumber = LoWord(menuresult);
  1250.  
  1251.     /* printf("Menu id: %d, item number: %d.\n", menuId, itemNumber); */
  1252.       
  1253.       switch (menuId) {
  1254.         case APPLE_MENU: 
  1255.             if (itemNumber == 1) aboutKevo();
  1256.             else {
  1257.               Str255  daName;
  1258.               GrafPtr savePort;
  1259.  
  1260.                 GetItem (appleMenu, itemNumber, daName);
  1261.                 GetPort(&savePort);
  1262.                 OpenDeskAcc(&daName);
  1263.                 SetPort(savePort);
  1264.             }                
  1265.             break;
  1266.  
  1267.           case FILE_MENU:
  1268.               switch (itemNumber) {
  1269.                 case NEW_TASK_MENUITEM: {
  1270.                     TASK** newTask = buildTask();
  1271.                     WindowPtr newWindow;
  1272.  
  1273.                     /* Build a new TextEdit window for the newly created task */
  1274.                     newWindow = buildTEWindow("\pKevo Task");
  1275.                     if (newWindow) {
  1276.                         (*newTask)->window = (int*)newWindow;
  1277.                         ShowWindow(newWindow);
  1278.                         SelectWindow(newWindow);
  1279.                     }
  1280.                     activateTask(newTask);
  1281.                     break;
  1282.                 }
  1283.                   case NEW_SCRIPT_MENUITEM: {
  1284.                       WindowPtr newWindow = buildTEWindow("\pKevo Transcript");
  1285.                      ShowWindow(newWindow);
  1286.                      SelectWindow(newWindow);
  1287.                       break;
  1288.                   }
  1289.                 case SAVE_IMAGE_MENUITEM: 
  1290.                     break;
  1291.                 case QUIT_MENUITEM:
  1292.                     pBye();
  1293.                     break;
  1294.             }
  1295.             break;
  1296.             
  1297.         case EDIT1_MENU:
  1298.         case EDIT2_MENU:
  1299.             if (SystemEdit(itemNumber-1)) break;
  1300.  
  1301.             switch (itemNumber) {
  1302.                 case BROWSE_MENUITEM /* Also UNDO */ :
  1303.                     if (theTask) {
  1304.                         OBJECT* target = getTaskCWD(theTask);
  1305.                         openBrowser(target, NIL, BrowserWKind);
  1306.                     }
  1307.                     else openBrowser(oUserRoot, "Root", BrowserWKind);
  1308.                     break;
  1309.                 case CUT_MENUITEM:
  1310.                     doCut();
  1311.                     break;
  1312.                 case COPY_MENUITEM:
  1313.                     doCopy();
  1314.                     break;
  1315.                 case PASTE_MENUITEM:                 
  1316.                     doPaste();
  1317.                     break;
  1318.                 case CLEAR_MENUITEM:
  1319.                     doRemove();
  1320.                     break;
  1321.                 case SELECT_ALL_MENUITEM:
  1322.                     doSelectAll();
  1323.                     break;
  1324.                 /* The edit operations below this point are used only in the browser mode */
  1325.                 case MKDIR_MENUITEM:
  1326.                     addNewCell(FrontWindow(), REF+8, "untitled");
  1327.                     break;
  1328.                 case ADD_VAR_MENUITEM:
  1329.                     addNewCell(FrontWindow(), VAR, "untitled");
  1330.                     break;
  1331.                 case ADD_SHAREDVAR_MENUITEM:
  1332.                     addNewCell(FrontWindow(), REF, "untitled");
  1333.                     break;
  1334.                 case ADD_METHOD_MENUITEM:
  1335.                     addNewCell(FrontWindow(), METHOD, "untitled");
  1336.                     break;
  1337.                 case HIDE_SHOW_MENUITEM:
  1338.                     doShowHide();
  1339.                     break;
  1340.                 case THIS_ONLY_MENUITEM:
  1341.                     whoToModify = THIS_ONLY;
  1342.                     break;
  1343.                 case WHOLE_FAMILY_MENUITEM:
  1344.                     whoToModify = WHOLE_FAMILY;
  1345.                     break;
  1346.                 case DERIVATIVES_MENUITEM:
  1347.                     whoToModify = DERIVATIVES;
  1348.                     break;
  1349.             }
  1350.             break;
  1351.  
  1352.         case TASKS_MENU:
  1353.             switch (itemNumber) {
  1354.                 case CANCEL_MENUITEM:
  1355.                     doCancel();
  1356.                     break;
  1357.                 case SUSPEND_MENUITEM:
  1358.                     if (theTask) {
  1359.                         if (yieldingSuspend(theTask)) 
  1360.                              fprintf(confile, "== Task %d suspended ==\n", theTask);
  1361.                         else fprintf(confile, "== Cannot suspend the only active task in the system ==\n");
  1362.                     }
  1363.                     else fprintf(confile, "== The current window contains no task which could be suspended ==\n");
  1364.                     break;
  1365.                 case ACTIVATE_MENUITEM:
  1366.                     if (theTask) {
  1367.                         activateTask(theTask);
  1368.                         fprintf(confile, "== Task %d activated ==\n", theTask);
  1369.  
  1370.                         /* If singletasking, start executing the just activated task */
  1371.                         if (!multitasking) doSelectTask(FrontWindow(), theTask);
  1372.                     }
  1373.                     else fprintf(confile, "== The current window contains no task which could be activated ==\n");
  1374.                     break;
  1375.                 case LOWER_PR_MENUITEM:
  1376.                     if (theTask) {
  1377.                         pushData((int)theTask);
  1378.                         pLowerPriority();
  1379.                         fprintf(confile, "== Task %d priority now %d ==\n", theTask, (*theTask)->priority);
  1380.                     }
  1381.                     else fprintf(confile, "== The current window contains no task whose priority could be lowered ==\n");
  1382.                     break;
  1383.                 case HIGHER_PR_MENUITEM:
  1384.                     if (theTask) {
  1385.                         pushData((int)theTask);
  1386.                         pRaisePriority();
  1387.                         fprintf(confile, "== Task %d priority now %d ==\n", theTask, (*theTask)->priority);
  1388.                     }
  1389.                     else fprintf(confile, "== The current window contains no task whose priority could be raised ==\n");
  1390.                     break;
  1391.             }
  1392.             break;
  1393.  
  1394.         case MULTITASK_MENU:
  1395.             switch (itemNumber) {
  1396.                 case PREEMPTIVE_MENUITEM:
  1397.                     cooperativeFlag = -1;
  1398.                     break;
  1399.                 case COOPERATIVE_MENUITEM:
  1400.                     cooperativeFlag = 1;
  1401.                     break;
  1402.                 case MON_MOFF_MENUITEM:
  1403.                     if (multitasking) { 
  1404.                         multitasking = FALSE;
  1405.                         doSelectTask(FrontWindow(), determineTask(FrontWindow()));
  1406.                     }
  1407.                     else multitasking = TRUE;
  1408.                     break;
  1409.                 case RESET_MENUITEM:
  1410.                     if (multitasking && mtaskMode == PREEMPTIVE) break;
  1411.  
  1412.                     multitasking = TRUE;
  1413.                     cooperativeFlag = -1; 
  1414.                     break;
  1415.             }
  1416.             break;
  1417.             
  1418.         case DEBUG_MENU:
  1419.             switch (itemNumber) {
  1420.                 case NOTRACE_MENUITEM:
  1421.                     traceFlag = QUITTRACE;
  1422.                     break;
  1423.                 case TRACE_MENUITEM:
  1424.                     traceFlag = TRACE;
  1425.                     break;
  1426.                 case FULLTRACE_MENUITEM:
  1427.                     traceFlag = FULLTRACE;
  1428.                     break;
  1429.                 case SET_BREAK_MENUITEM:
  1430.                     if (theTask) {    
  1431.                         char c;
  1432.                         char*    ClipBuf = (char*)*TEScrapHandle();
  1433.                         int        ClipLen = TEGetScrapLen();
  1434.  
  1435.                         textToKeyBuffer(theTask, "' ");
  1436.                         while (ClipLen-- && (c = *ClipBuf++) > BL) putToKeyBuffer(theTask, c);
  1437.                         textToKeyBuffer(theTask, " debug");
  1438.  
  1439.                         /* Command lines must be separated by two returns or linefeeds */
  1440.                         crsToKeyBuffer(theTask);
  1441.                     }
  1442.                     else noActiveTask();
  1443.                     break;
  1444.                 case REMOVE_BREAK_MENUITEM:
  1445.                     if (theTask) {    
  1446.                         char c;
  1447.                         char*    ClipBuf = (char*)*TEScrapHandle();
  1448.                         int        ClipLen = TEGetScrapLen();
  1449.  
  1450.                         textToKeyBuffer(theTask, "' ");
  1451.                         while (ClipLen-- && (c = *ClipBuf++) > BL) putToKeyBuffer(theTask, c);
  1452.                         textToKeyBuffer(theTask, " unbug");
  1453.  
  1454.                         /* Command lines must be separated by two returns or linefeeds */
  1455.                         crsToKeyBuffer(theTask);
  1456.                     }
  1457.                     else noActiveTask();
  1458.                     break;
  1459.                 case RESUME_MENUITEM:
  1460.                     if (theTask) {
  1461.                         textToKeyBuffer(theTask, "resume");
  1462.                         crsToKeyBuffer(theTask);
  1463.                     }
  1464.                     else noActiveTask();
  1465.                     break;
  1466.             }
  1467.             break;
  1468.  
  1469.         case VIEW_MENU:
  1470.             switch (itemNumber) {
  1471.                 case VIEW_OPER_MENUITEM: {
  1472.                         ListHandle iconList = getBrowserIcons(FrontWindow());
  1473.                         if (getViewMode(iconList) == BEHAVIOR) break;
  1474.                         setViewMode(iconList, BEHAVIOR);
  1475.                         updateBrowser(FrontWindow());
  1476.                     }
  1477.                     break;
  1478.                 case VIEW_DATA_MENUITEM: {
  1479.                         ListHandle iconList = getBrowserIcons(FrontWindow());
  1480.                         if (getViewMode(iconList) == DATA) break;
  1481.                         setViewMode(iconList, DATA);
  1482.                         updateBrowser(FrontWindow());
  1483.                     }
  1484.                     break;
  1485.                 case VIEW_BOTH_MENUITEM: {
  1486.                         ListHandle iconList = getBrowserIcons(FrontWindow());
  1487.                         if (getViewMode(iconList) == ALL) break;
  1488.                         setViewMode(iconList, ALL);
  1489.                         updateBrowser(FrontWindow());
  1490.                     }
  1491.                     break;
  1492.                 case SHOW_ROOT_MENUITEM:
  1493.                     openBrowser(oUserRoot, "Root", BrowserWKind);
  1494.                     break;
  1495.                 case SHOW_CLONEF_MENUITEM: {
  1496.                     /* Open a browser for the clone family object */
  1497.                     OBJECT* cwd = getBrowserTarget(FrontWindow());
  1498.                     LIST*  cf  = (LIST*)getContext(cwd)->cloneFamily;
  1499.  
  1500.                     /* Clone family field is zero or clone family size is zero -> do nothing */
  1501.                     if (!cf || cf->logicalSize == 0) {
  1502.                         SysBeep(1);
  1503.                         break;
  1504.                     }
  1505.  
  1506.                     openBrowser((OBJECT*)cf, NIL, CloneBrWKind);
  1507.                     break;
  1508.                 }
  1509.                 case SHOW_PARENTF_MENUITEM: {
  1510.                     browseCloneFamilies(FrontWindow(), "parent");
  1511.                     break;
  1512.                 }
  1513.                 case SHOW_CHILDF_MENUITEM: {
  1514.                     browseCloneFamilies(FrontWindow(), "child");
  1515.                     break;
  1516.                 }
  1517.                 case ONE_COLUMN_MENUITEM:
  1518.                     recolumnBrowser(FrontWindow(), 1);
  1519.                     break;
  1520.                 case FOUR_COLUMNS_MENUITEM: {
  1521.                     recolumnBrowser(FrontWindow(), 4);
  1522.                     break;
  1523.                 }
  1524.                 case UPDATE_MENUITEM:
  1525.                     /* For speed, use 'refreshBrowser' rather than 'updateBrowser' */
  1526.                     refreshBrowser(FrontWindow());
  1527.                     break;
  1528.             }
  1529.             break;
  1530.             
  1531.         case TOOLS_MENU: {
  1532.             WindowPtr browserWindow = FrontWindow();
  1533.             OBJECT* cwd = getBrowserTarget(browserWindow);
  1534.  
  1535.             switch (itemNumber) {
  1536.                 case SHARE_MENUITEM:
  1537.                     if (respondsTo(cwd, "share") && respondsTo(cwd, "browse")) {
  1538.                         numberToKeyBuffer(browserTask, (int)cwd);
  1539.                         textToKeyBuffer(browserTask, ".share.browse");
  1540.                         crsToKeyBuffer(browserTask);
  1541.                     }
  1542.                     break;
  1543.                 case CLONE_MENUITEM:
  1544.                     if (respondsTo(cwd, "clone") && respondsTo(cwd, "browse")) {
  1545.                         numberToKeyBuffer(browserTask, (int)cwd);
  1546.                         textToKeyBuffer(browserTask, ".clone.browse");
  1547.                         crsToKeyBuffer(browserTask);
  1548.                     }
  1549.                     break;
  1550.                 case NEW_MENUITEM:
  1551.                     if (respondsTo(cwd, "new") && respondsTo(cwd, "browse")) {
  1552.                         numberToKeyBuffer(browserTask, (int)cwd);
  1553.                         textToKeyBuffer(browserTask, ".new.browse");
  1554.                         crsToKeyBuffer(browserTask);
  1555.                     }
  1556.                     break;
  1557.  
  1558. /* This has been removed from the menus:
  1559.                 case DEEP_COPY_MENUITEM:
  1560.                     if (respondsTo(cwd, "deepCopy") && respondsTo(cwd, "browse")) {
  1561.                         numberToKeyBuffer(browserTask, (int)cwd);
  1562.                         textToKeyBuffer(browserTask, ".deepCopy.browse");
  1563.                         crsToKeyBuffer(browserTask);
  1564.                     }
  1565.                     break;
  1566. */
  1567.                 case ASSIGN_MENUITEM: {
  1568.                     /* The object to be assigned must be the second topmost window */
  1569.                     WindowPtr secondWindow = (WindowPtr)((WindowPeek)browserWindow)->nextWindow;
  1570.                     OBJECT* source;
  1571.                     
  1572.                     if (secondWindow && getWindowKind(secondWindow) == BrowserWKind &&
  1573.                         (source = getBrowserTarget(secondWindow)))
  1574.                         assignObject(browserWindow, source);
  1575.                     else {
  1576.                         SysBeep(1);
  1577.                         fprintf(confile, "== Cannot assign (the second topmost window is not an object/browser) ==\n");
  1578.                     }
  1579.                     break;
  1580.                 }
  1581.                 case OPEN_SHELL_MENUITEM:
  1582.                     openShellForThis(cwd); 
  1583.                     break;
  1584.             }
  1585.             break;
  1586.         }
  1587.  
  1588.         case WINDOW_MENU: {
  1589.             switch (itemNumber) {
  1590.                 case HIDE_WINDOW_MENUITEM:
  1591.                     HideWindow(FrontWindow());
  1592.                     break;
  1593.                 case MOVE_BEHIND_MENUITEM:
  1594.                     SendBehind(FrontWindow(), 0);
  1595.                     break;
  1596.                 case CLOSE_BROWSERS_MENUITEM: {
  1597.                     WindowPtr thisBr = LastBrowser;
  1598.                     WindowPtr tempBr;
  1599.                     OBJECT*      target;
  1600.  
  1601.                     if (countVisibleWindows() <= 1) {
  1602.                         fprintf(confile, "== Cannot close the only visible window in the system ==\n");
  1603.                         break;
  1604.                     }
  1605.                     
  1606.                     while (thisBr) {
  1607.                         tempBr = getPrevBrowser(thisBr);
  1608.                         target = getBrowserTarget(thisBr);
  1609.  
  1610.                         if (multitasking) {
  1611.                         /* 
  1612.                             Set the browser to be deleted by the browser task so as to allow
  1613.                             multitasking to operate without interruption.
  1614.  
  1615.                             In singletasking mode, we must delete the browsers directly
  1616.                             using 'deleteBrowser', since the browser task may not be active.
  1617.                         */
  1618.                             numberToKeyBuffer(browserTask, (int)target);
  1619.                             textToKeyBuffer(browserTask, " unbrowse");
  1620.                             crsToKeyBuffer(browserTask);
  1621.                         }
  1622.                         else deleteBrowser(thisBr);
  1623.  
  1624.                         thisBr = tempBr;
  1625.                     } 
  1626.                     break;
  1627.                 }
  1628.                 default: {
  1629.                     /* Select the correct window, and show it if it is currently invisible */
  1630.                     /* The menu contains five items before the window names */
  1631.     
  1632.                     WindowPtr thisWindow = FrontWindow();
  1633.                     int count = itemNumber-5;
  1634.                     short menuMark;
  1635.             
  1636.                     while (--count) thisWindow = (WindowPtr)((WindowPeek)thisWindow)->nextWindow;
  1637.                     GetItemMark(windowMenu, itemNumber, &menuMark);
  1638.                     if (menuMark) ShowWindow(thisWindow);
  1639.                     SelectWindow(thisWindow);
  1640.                     break;
  1641.                 }
  1642.             }
  1643.         }
  1644.     }
  1645.             
  1646.     HiliteMenu(FALSE);
  1647. }
  1648.  
  1649.